import 'dart:math';

import 'package:decimal/decimal.dart';
import 'package:flutter_09_game/utils/log/utils_log.dart';

extension NumExt on num? {
  /// 格式化奖池金额
  /// 将原始数值除以1000000并格式化为千分位显示，保留2位小数
  String formatAmount() {
    if (this == null) return '0.00';

    // 除以1000000转换单位
    double convertedAmount = (this ?? 0) / 1000000.0;

    // 格式化为千分位显示，保留2位小数
    return convertedAmount.toStringAsFixed(2).replaceAllMapped(
          RegExp(r'(\d{1,3})(?=(\d{3})+(?!\d))'),
          (Match match) => '${match[1]},',
        );
  }

  String formatRebateRate() {
    if (this == null) return '--';
    return '${((this ?? 0) / 100).toStringAsFixed(2)}%';
  }

  // String formatWallet({int fixed = 2, int divisor = 1000000}) {
  //   if (this == null) return '0.${'0' * fixed}';
  //
  //   // 将数值统一转为整数计算，防止浮点精度丢失
  //   final multiplier = math.pow(10, fixed).toInt();
  //   final scaledValue = (this! * multiplier ~/ divisor); // 整除截断
  //   final integerPart = scaledValue ~/ multiplier;
  //   final fractionalPart = scaledValue % multiplier;
  //
  //
  //   final fractionalStr = fractionalPart.toString().padLeft(fixed, '0');
  //   return '$integerPart.$fractionalStr';
  // }

  /// 将输入数除以 1_000_000 并**截断**保留两位小数，返回字符串（总是保留两位小数）
  /// 支持输入类型：String / int / BigInt / double / num
  // String divideMillionTruncateTwo(String input) {
  //   // 标准化输入为字符串（去掉空格）
  //   final s = input.trim();
  //   if (s.isEmpty) throw ArgumentError('empty input');
  //
  //   // 处理符号
  //   bool negative = false;
  //   String work = s;
  //   if (work.startsWith('+')) work = work.substring(1);
  //   if (work.startsWith('-')) {
  //     negative = true;
  //     work = work.substring(1);
  //   }
  //   if (work.isEmpty) throw ArgumentError('invalid number');
  //
  //   // 如果包含指数形式（e/E），将其转换为完整的十进制字符串
  //   // 简单处理：使用 Dart 的 Decimal-free 方法：BigInt + scale via double if necessary.
  //   // 为避免复杂性，尽量让调用方传入普通十进制字符串（如 "12345.678" 或 "12345678"）。
  //   if (work.contains(RegExp(r'[eE]'))) {
  //     // 使用 double 转换为非指数形式（注意：如果用户传入指数且很大，double 可能丢失精度）
  //     work = double.parse((negative ? '-' : '') + work).toString();
  //     if (work.startsWith('-')) {
  //       negative = true;
  //       work = work.substring(1);
  //     }
  //   }
  //
  //   // 分离整数和小数部分
  //   String intPart = work;
  //   String fracPart = '';
  //   if (work.contains('.')) {
  //     final parts = work.split('.');
  //     intPart = parts[0];
  //     fracPart = parts.length > 1 ? parts[1] : '';
  //   }
  //
  //   // 清理前导0（但保留单个0）
  //   if (intPart.isEmpty) intPart = '0';
  //
  //   // numerator = integer concatenated with fracPart as BigInt
  //   final numerator =
  //       BigInt.parse((intPart + (fracPart.isEmpty ? '' : fracPart)));
  //   final denom = BigInt.from(10).pow(fracPart.length); // 10^fracLen
  //
  //   // 我们要得到： result = numerator / denom / 1_000_000
  //   // 为了保留两位小数并截断，计算 scaled = floor(numerator * 100 / (denom * 1_000_000))
  //   final scaleMultiplier = BigInt.from(100);
  //   final million = BigInt.from(1000000);
  //   final scaledNumerator = numerator * scaleMultiplier;
  //   final scaledDenom = denom * million;
  //
  //   final scaled = scaledNumerator ~/ scaledDenom; // 整数除法 => 截断（向0）
  //
  //   // scaled 表示 result * 100 的整数部分（已截断）
  //   final absScaled = scaled.abs();
  //
  //   final integerPart = (absScaled ~/ BigInt.from(100)).toString();
  //   final decimalPart =
  //       (absScaled % BigInt.from(100)).toString().padLeft(2, '0');
  //
  //   final result =
  //       '${negative && (scaled != BigInt.zero) ? '-' : ''}$integerPart.$decimalPart';
  //   return result;
  // }
  //
  // /// 辅助：接受 num 类型（int/double等），将其转换为字符串再调用上面函数。
  // /// 注意：double 转为字符串时可能带有浮点误差。如果你关心极高精度，建议传入字符串或整数。
  String formatWallet({int fixed = 2}) {
    if (this == null) return '0.00';

    // 转为 Decimal，避免 double 精度丢失
    final Decimal value = Decimal.parse(this!.toString());

    // 除以 1_000_000
    final Decimal divided = (value / Decimal.fromInt(1000000)).toDecimal();

    // 计算截断系数（10^fixed）
    final Decimal scale = Decimal.fromInt(pow(10, fixed).toInt());

    // 手动截断：先放大 -> 取整 -> 缩小
    final Decimal scaled = divided * scale;
    final BigInt truncatedInt = scaled.toBigInt(); // 舍弃小数部分（不四舍五入）
    final Decimal truncated =
        (Decimal.fromBigInt(truncatedInt) / scale).toDecimal();

    // 保证固定小数位格式
    final parts = truncated.toString().split('.');

    if (parts.length == 1) {
      // return '';
      return '${parts[0]}.${'0' * fixed}';

    } else {
      // return '';
      final dec = parts[1].padRight(fixed, '0').substring(0, fixed);
      return '${parts[0]}.$dec';
    }
  }

  // String formatWallet({int fixed = 2}) {
  //   if (this == null) return '0.00';

  //   // 使用整数运算避免浮点精度问题
  //   // 例如：输入 38800000，除数 1000000，保留 2 位小数

  //   int originalValue = this!.toInt();
  //   int divisor = 1000000;

  //   // 计算整数部分：38800000 ~/ 1000000 = 38
  //   int integerPart = originalValue ~/ divisor;

  //   // 计算余数：38800000 % 1000000 = 800000
  //   int remainder = originalValue % divisor;

  //   // 将余数转换为小数部分并截断到指定位数
  //   // 800000 * 100 / 1000000 = 80（表示 0.80）
  //   int multiplier = pow(10, fixed).toInt();
  //   int fractionalPart = (remainder * multiplier) ~/ divisor;

  //   // 格式化输出：整数部分.小数部分
  //   // 小数部分需要补零到指定位数
  //   String fractionalStr = fractionalPart.toString().padLeft(fixed, '0');

  //   return '$integerPart.$fractionalStr';
  // }

  String formatLimiting() {
    if (this == null) return '0';

    // 除以1000000转换单位
    double convertedAmount = (this ?? 0) / 1000000.0;
    return convertedAmount.toInt().toString();
  }

  String formatHomePool() {
    if (this == null) return '0';

    return (this ?? 0).toString().replaceAllMapped(
          RegExp(r'(\d{1,3})(?=(\d{3})+(?!\d))'),
          (Match match) => '${match[1]},',
        );
  }
}
